<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<html>
<head>
  <meta http-equiv="Content-Language" content="en-us">
  <meta http-equiv="Content-Type" content="text/html; charset=us-ascii">

  <title>Boost Function Object Adapter Library</title>
</head>

<body bgcolor="#FFFFFF" text="#000000">
  <table border="1" bgcolor="#007F7F" cellpadding="2" summary="">
    <tr>
      <td bgcolor="#FFFFFF"><img src="../../boost.png" alt=
      "boost.png (6897 bytes)" width="277" height="86"></td>

      <td><a href="../../index.htm"><font face="Arial" color=
      "#FFFFFF"><big>Home</big></font></a></td>

      <td><a href="../libraries.htm"><font face="Arial" color=
      "#FFFFFF"><big>Libraries</big></font></a></td>

      <td><a href="http://www.boost.org/people/people.htm"><font face="Arial" color=
      "#FFFFFF"><big>People</big></font></a></td>

      <td><a href="http://www.boost.org/more/faq.htm"><font face="Arial" color=
      "#FFFFFF"><big>FAQ</big></font></a></td>

      <td><a href="../../more/index.htm"><font face="Arial" color=
      "#FFFFFF"><big>More</big></font></a></td>
    </tr>
  </table>

  <h1>Negators</h1>

  <p>The header <a href="../../boost/functional.hpp">functional.hpp</a>
  provides enhanced versions of both the negator adapters from the C++
  Standard Library (&sect;20.3.5):</p>

  <ul>
    <li><tt>unary_negate</tt></li>

    <li><tt>binary_negate</tt></li>
  </ul>

  <p>As well as the corresponding helper functions</p>

  <ul>
    <li><tt>not1</tt></li>

    <li><tt>not2</tt></li>
  </ul>

  <p>However, the negators in this library improve on the standard versions
  in two ways:</p>

  <ul>
    <li>They use <a href="function_traits.html">function object traits</a> to
    avoid the need for <tt>ptr_fun</tt> when negating a function rather than
    an adaptable function object.</li>

    <li>They use Boost <a href=
    "../utility/call_traits.htm">call&nbsp;traits</a> to determine the best
    way to declare their arguments and pass them through to the adapted
    function (see <a href="#arguments">below</a>).</li>
  </ul>

  <h3>Usage</h3>

  <p>Usage is identical to the standard negators. For example,</p>

  <blockquote>
    <pre>
bool bad(const Foo &amp;foo) { ... }
...
std::vector&lt;Foo&gt; c;
...
std::find_if(c.begin(), c.end(), boost::not1(bad));
</pre>
  </blockquote>

  <h3 id="arguments">Argument Types</h3>

  <p>The C++ Standard (&sect;20.3.5) defines unary negate like this (binary
  negate is similar):</p>

  <blockquote>
    <pre>
template &lt;class Predicate&gt;
  class unary_negate
    : public unary_function&lt;typename Predicate::argument_type,bool&gt; {
public:
  explicit unary_negate(const Predicate&amp; pred);
  bool operator()(<strong>const typename Predicate::argument_type&amp;</strong> x) const;
};
</pre>
  </blockquote>

  <p>Note that if the Predicate's <tt>argument_type</tt> is a reference, the
  type of <tt>operator()</tt>'s argument would be a reference to a reference.
  Currently this is illegal in C++ (but see the <a href=
  "http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#106">C++
  standard core language active issues list</a>).</p>

  <p>However, if we instead defined <tt>operator()</tt> to accept Predicate's
  argument_type unmodified, this would be needlessly inefficient if it were a
  value type; the argument would be copied twice - once when calling
  <tt>unary_negate</tt>'s <tt>operator()</tt>, and again when
  <tt>operator()</tt> called the adapted function.</p>

  <p>So how we want to declare the argument for <tt>operator()</tt> depends
  on whether or not the Predicate's <tt>argument_type</tt> is a reference. If
  it is a reference, we want to declare it simply as <tt>argument_type</tt>;
  if it is a value we want to declare it as
  <tt>const&nbsp;argument_type&amp;</tt>.</p>

  <p>The Boost <a href="../utility/call_traits.htm">call_traits</a> class
  template contains a <tt>param_type</tt> typedef, which uses partial
  specialisation to make precisely this decision. If we were to declare
  <tt>operator()</tt> as</p>

  <blockquote>
    <pre>
bool operator()(typename call_traits&lt;typename Predicate::argument_type&gt;::param_type x) const
</pre>
  </blockquote>

  <p>the desired result would be achieved - we would eliminate references to
  references without loss of efficiency. In fact, the actual declaration is
  slightly more complicated because of the use of function object traits, but
  the effect remains the same.</p>

  <h3>Limitations</h3>

  <p>Both the function object traits and call traits used to realise these
  improvements rely on partial specialisation, these improvements are only
  available on compilers that support that feature. With other compilers, the
  negators in this library behave very much like those in the Standard -
  <tt>ptr_fun</tt> will be required to adapt functions, and references to
  references will not be avoided.</p>
  <hr>

  <p><a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
  "../../doc/images/valid-html401.png" alt="Valid HTML 4.01 Transitional"
  height="31" width="88"></a></p>

  <p>Revised 
  <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->02
  December, 2006<!--webbot bot="Timestamp" endspan i-checksum="38510" --></p>

  <p><i>Copyright &copy; 2000 Cadenza New Zealand Ltd.</i></p>

  <p><i>Distributed under the Boost Software License, Version 1.0. (See
  accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
  copy at <a href=
  "http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</i></p>
</body>
</html>
